#ifndef __ISO_STANDARD_CPP_H__
#define __ISO_STANDARD_CPP_H__

class help_introduce{
    // C++ 11 FAQ https://wizardforcel.gitbooks.io/cpp-11-faq/content/85.html
    // 包含所有的头文件
    // #include <bits/stdc++.h>
    // 容器库 https://zh.cppreference.com/w/cpp/container
    // http://www.cplusplus.com/reference/memory/allocator/

};

class help_keywords{
// 基本数据类型
// bool
// char
// char16_t
// char32_t
// char8_t
// double
// float
// int
// short
// wchar_t
// long
// signed
// unsigned
// auto

//基本常量
// false
// true
// nullptr


//修饰符
// public
// protected
// private

// const
// static
// volatile
// final
// friend
// inline
// operator
// override



// 流程控制
// break
// case
// catch
// default
// do
// else
// for
// goto
// if
// switch
// throw
// try
// void
// while
// return
// continue


// 数据类型及类
// class
// struct
// union
// enum
// namespace
// using
// template
// typedef
// typeid
// typename




// const_cast
// dynamic_cast
// reinterpret_cast
// static_cast
// static_assert

// alignas
// alignof
// asm
// audit
// axiom
// compl
// concept
// consteval
// constexpr

// co_await
// co_return
// co_yield
// decltype
// delete
// explicit
// export
// extern
// keywords
// mutable
// new
// noexcept  /*指定函数是否抛出异常,该关键字告诉编译器，函数中不会发生异常,这有利于编译器对程序做更多的优化 Since C++11 */
// register
// requires



// this
// thread_local
// virtual

/** c++ 操作符替代 **/
// sizeof
// and
// and_eq
// or
// or_eq
// not
// not_eq
// xor
// xor_eq
// bitand
// bitor

};


class help_header{
// https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#S-interfaces

// Iterators library
// <iterator>	Range iterators
// Ranges library

// Algorithms library
// <algorithm>	Algorithms that operate on ranges

// Numerics library
// <cmath>		Common mathematics functions
// <complex>	Complex number type
// <valarray>	Class for representing and manipulating arrays of values
// <numeric>	Numeric operations on values in containers


// Input/output library
// <iosfwd>		forward declarations of all classes in the input/output library
// <ios>		std::ios_base class, std::basic_ios class template and several typedefs
// <istream>	std::basic_istream class template and several typedefs
// <ostream>	std::basic_ostream, std::basic_iostream class templates and several typedefs
// <iostream>	several standard stream objects
// <fstream>	std::basic_fstream, std::basic_ifstream, std::basic_ofstream class templates and several typedefs
// <sstream>	std::basic_stringstream, std::basic_istringstream, std::basic_ostringstream class templates and several typedefs

// <iomanip>	Helper functions to control the format of input and output
// <streambuf>	std::basic_streambuf class template
// <cstdio>	C-style input-output functions
// Localization library
// <locale>	Localization utilities
// <clocale>	C localization utilities

// --------------------------------------------------------------------------------
// Since C++11
// --------------------------------------------------------------------------------
// Regular Expressions library
// <regex> (since C++11)	Classes, algorithms and iterators to support regular expression processing
// Atomic Operations library

// Thread support library

// Filesystem library

// <chrono>             (since C++11)	C++ time utilites
// <initializer_list>   (since C++11)	std::initializer_list class template
// <tuple>              (since C++11)	std::tuple class template
// <typeindex>          (since C++11)	std::type_index
// <type_traits>        (since C++11)	Compile-time type information
// <cuchar>             (since C++11)	C-style Unicode character conversion functions

// <array>              (since C++11)	std::array container
// <forward_list>       (since C++11)	std::forward_list container
// <unordered_set>      (since C++11)	std::unordered_set and std::unordered_multiset unordered associative containers
// <unordered_map>      (since C++11)	std::unordered_map and std::unordered_multimap unordered associative containers

// <random>             (since C++11)	Random number generators and distributions
// <ratio>              (since C++11)	Compile-time rational arithmetic
// <cfenv>              (since C++11)	Floating-point environment access functions
// <codecvt>            (since C++11)(deprecated in C++17)	Unicode conversion facilities


// <atomic>             (since C++11)	Atomic operations library

// <thread>             (since C++11)	std::thread class and supporting functions
// <mutex>              (since C++11)	mutual exclusion primitives
// <future>             (since C++11)	primitives for asynchronous computations
// <condition_variable> (since C++11)	thread waiting conditions
// <scoped_allocator>   (since C++11)	Nested allocator class
// <cstdint>            (since C++11)	fixed-size types and limits of other types
// <cinttypes>          (since C++11)	formatting macros , intmax_t and uintmax_t math and conversions
// <system_error>       (since C++11)	defines std::error_code, a platform-dependent error code



// --------------------------------------------------------------------------------
// Since C++14
// --------------------------------------------------------------------------------
// <shared_mutex> (since C++14)	shared mutual exclusion primitives



// --------------------------------------------------------------------------------
// Since C++17
// --------------------------------------------------------------------------------
// <any>             (since C++17)	std::any class
// <optional>        (since C++17)	std::optional class template
// <variant>         (since C++17)	std::variant class template
// <filesystem>      (since C++17)	std::path class and supporting functions
// <memory_resource> (since C++17)	Polymorphic allocators and memory resources
// <string_view>     (since C++17)	std::basic_string_view class template
// <charconv>        (since C++17)	std::to_chars and std::from_chars
// <execution>       (since C++17)	Predefined execution policies for parallel versions of the algorithms

// --------------------------------------------------------------------------------
// Since C++20
// --------------------------------------------------------------------------------
// Coroutines library 
// <compare>   (since C++20)	Three-way comparison operator support
// <version>   (since C++20)	supplies implementation-dependent library information

// Concepts library
// <concepts>   (since C++20)	Fundamental library concepts

// Coroutines library
// <coroutine>  (since C++20)	Coroutine support library
// <contract>   (since C++20)	Contract violation information
// <span>       (since C++20)	std::span view
// <ranges>     (since C++20)	Range access, primitives, requirements, utilities and adaptors
// <bit>        (since C++20)	Bit manipulation functions
// <syncstream> (since C++20)	std::basic_osyncstream, std::basic_syncbuf, and typedefs



};


class help_guide{
/* C++ 标准模板库的核心包括以下三个组件:容器（Containers）、算法（Algorithms、迭代器（terators） 

组件	描述
容器    （Containers）	容器是用来管理某一类对象的集合。C++ 提供了各种不同类型的容器，比如 deque、list、vector、map 等。
算法    （Algorithms）	算法作用于容器。它们提供了执行各种操作的方式，包括对容器内容执行初始化、排序、搜索和转换等操作。
迭代器（iterators）	迭代器用于遍历对象集合的元素。这些集合可能是容器，也可能是容器的子集。  

Sequence containers 包括：
    array（static contiguous array Since C++11）
    vector（dynamic contiguous array ）
    deque（double-ended queue ）
    forward_list（singly-linked list Since C++11）
    list（doubly-linked list ）

Container adaptors 包括：
	///< Container adaptors provide a different interface for sequential containers.
    stack（adapts a container to provide stack (LIFO data structure) ）
    queue（adapts a container to provide queue (FIFO data structure) ）
    priority_queue（adapts a container to provide priority queue ）
    
Associative containers 包括：
    set（collection of unique keys, sorted by keys ）
    map（collection of key-value pairs, sorted by keys, keys are unique ）
    multiset（collection of keys, sorted by keys ）
    multimap（collection of key-value pairs, sorted by keys ）

Unordered associative containers 包括：
	///< Unordered associative containers implement unsorted (hashed) data structures that 
	///< can be quickly searched (O(1) amortized, O(n) worst-case complexity).
    unordered_set（collection of unique keys, hashed by keys Since C++11）
    unordered_map (collection of key-value pairs, hashed by keys, keys are unique Since C++11)
    unordered_multiset (collection of keys, hashed by keys Since C++11)
    unordered_multimap (collection of key-value pairs, hashed by keys Since C++11)


*/
};
namespace std
{
	#define noexcept

	template<class E> 
	class initializer_list
	{
	public:
		using value_type = E;
		using reference = const E&;
		using const_reference = const E&;
		using size_type = size_t;
		using iterator = const E*;
		using const_iterator = const E*;
		constexpr initializer_list() noexcept;
		constexpr size_t size() const noexcept; // number of elements
		constexpr const E* begin() const noexcept; // first element
		constexpr const E* end() const noexcept; // one past the last element
	};
	// initializer list range access
	template<class E> constexpr const E* begin(initializer_list<E> il) noexcept;
	template<class E> constexpr const E* end(initializer_list<E> il) noexcept;


};



#define tag_string
/**
* @header 
<string>
<regex>
*/

Headers:


namespace std
{
	/**
	 * <string>
	 * https://zh.cppreference.com/w/cpp/string
	 * @help_guide
	 * Array header (since C++11) 
	 * Header that defines the fixed-size array container class:
	 * C++ 字符串库支持三种通用字符串类型：

		std::basic_string ——为操作任何字符类型的字符串设计的模板类。
		std::basic_string_view (C++17) ——对于字符串子序列的轻量无所有权的只读视图。
		空终止字符串 - 以特殊的空字符终止的字符数组。
	 */
	/**
	* @header  <string>
	* @refer https://zh.cppreference.com/w/cpp/string
	* @desc C++ 字符串库
	* @history (since C++11) 
	* @sample
	**/

	///< 元素访问

	typedef std::basic_string<char> string;
	typedef std::basic_string<wchar_t> wstring;
	typedef std::basic_string<char8_t> u8string; 	///< Since C++20
	typedef std::basic_string<char16_t> u16string; 	///< Since C++11
	typedef std::basic_string<char32_t> u32string;  ///< Since C++11

	
	template<class charT, class traits = char_traits<charT>>
	class basic_string_view 
	{
		public:
		// types
		typedef traits traits_type;
		typedef charT value_type;
		typedef charT* pointer;
		typedef const charT* const_pointer;
		typedef charT& reference;
		typedef const charT& const_reference;
		typedef /*implementation-defined*/ const_iterator;
		typedef const_iterator iterator;
		typedef reverse_iterator<const_iterator> const_reverse_iterator;
		typedef const_reverse_iterator reverse_iterator;
		typedef size_t size_type;
		typedef ptrdiff_t difference_type;
		static constexpr size_type npos = size_type(-1);
		 
		// construction and assignment
		constexpr basic_string_view() noexcept;
		constexpr basic_string_view(const basic_string_view&) noexcept = default;
		basic_string_view &operator=(const basic_string_view&) noexcept = default;
		constexpr basic_string_view(const charT* str);
		constexpr basic_string_view(const charT* str, size_type len);
		 
		// iterator support
		constexpr const_iterator begin() const noexcept;
		constexpr const_iterator end() const noexcept;
		constexpr const_iterator cbegin() const noexcept;
		constexpr const_iterator cend() const noexcept;
		constexpr const_reverse_iterator rbegin() const noexcept;
		constexpr const_reverse_iterator rend() const noexcept;
		constexpr const_reverse_iterator crbegin() const noexcept;
		constexpr const_reverse_iterator crend() const noexcept;
		 
		// capacity
		constexpr size_type size() const noexcept;
		constexpr size_type length() const noexcept;
		constexpr size_type max_size() const noexcept;
		[[nodiscard]] constexpr bool empty() const noexcept;
		 
		// element access
		constexpr const_reference operator[](size_type pos) const;
		constexpr const_reference at(size_type pos) const;
		constexpr const_reference front() const;
		constexpr const_reference back() const;
		constexpr const_pointer data() const noexcept;
		 
		// modifiers
		constexpr void remove_prefix(size_type n);
		constexpr void remove_suffix(size_type n);
		constexpr void swap(basic_string_view& s) noexcept;
		 
		constexpr size_type copy(charT* s, size_type n, size_type pos = 0) const;
		constexpr basic_string_view substr(size_type pos = 0, size_type n = npos) const;
		constexpr int compare(basic_string_view s) const noexcept;
		constexpr int compare(size_type pos1, size_type n1, basic_string_view s) const;
		constexpr int compare(size_type pos1, size_type n1, basic_string_view s,size_type pos2, size_type n2) const;
		constexpr int compare(const charT* s) const;
		constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
		constexpr int compare(size_type pos1, size_type n1, const charT* s, size_type n2) const;
		constexpr bool starts_with(basic_string_view x) const noexcept;
		constexpr bool starts_with(charT x) const noexcept;
		constexpr bool starts_with(const charT* x) const;
		constexpr bool ends_with(basic_string_view x) const noexcept;
		constexpr bool ends_with(charT x) const noexcept;
		constexpr bool ends_with(const charT* x) const;
		constexpr size_type find(basic_string_view s, size_type pos = 0) const noexcept;
		constexpr size_type find(charT c, size_type pos = 0) const noexcept;
		constexpr size_type find(const charT* s, size_type pos, size_type n) const;
		constexpr size_type find(const charT* s, size_type pos = 0) const;
		constexpr size_type rfind(basic_string_view s, size_type pos = npos) const noexcept;
		constexpr size_type rfind(charT c, size_type pos = npos) const noexcept;
		constexpr size_type rfind(const charT* s, size_type pos, size_type n) const;
		constexpr size_type rfind(const charT* s, size_type pos = npos) const;
		constexpr size_type find_first_of(basic_string_view s, size_type pos = 0) const noexcept;
		constexpr size_type find_first_of(charT c, size_type pos = 0) const noexcept;
		constexpr size_type find_first_of(const charT* s, size_type pos, size_type n) const;
		constexpr size_type find_first_of(const charT* s, size_type pos = 0) const;
		constexpr size_type find_last_of(basic_string_view s, size_type pos = npos) const noexcept;
		constexpr size_type find_last_of(charT c, size_type pos = npos) const noexcept;
		constexpr size_type find_last_of(const charT* s, size_type pos, size_type n) const;
		constexpr size_type find_last_of(const charT* s, size_type pos = npos) const;
		constexpr size_type find_first_not_of(basic_string_view s, size_type pos = 0) const noexcept;
		constexpr size_type find_first_not_of(charT c, size_type pos = 0) const noexcept;
		constexpr size_type find_first_not_of(const charT* s, size_type pos, size_type n) const;
		constexpr size_type find_first_not_of(const charT* s, size_type pos = 0) const;
		constexpr size_type find_last_not_of(basic_string_view s,size_type pos = npos) const noexcept;
		constexpr size_type find_last_not_of(charT c, size_type pos = npos) const noexcept;
		constexpr size_type find_last_not_of(const charT* s, size_type pos, size_type n) const;
		constexpr size_type find_last_not_of(const charT* s, size_type pos = npos) const;
		private:
		const_pointer data_; // exposition only
		size_type size_; // exposition only
	};
	typedef std::basic_string_view<char>     string_view; ///< Since C++17
	typedef std::basic_string_view<wchar_t>  wstring_view; ///< Since C++17
	typedef std::basic_string_view<char8_t>  u8string_view; ///< Since C++20
	typedef std::basic_string_view<char16_t> u16string_view; ///< Since C++17
	typedef std::basic_string_view<char32_t> u32string_view; ///< Since C++17

	/**
	* @header  <regex>
	* @refer https://zh.cppreference.com/w/cpp/regex
	* @desc 正则表达式 字符串匹配
	* @history (since C++11) 
	* @sample
	// regex_match example
	#include <iostream>
	#include <string>
	#include <regex>
	
	int main ()
	{
	
	  if (std::regex_match ("subject", std::regex("(sub)(.*)") ))
		std::cout << "string literal matched\n";
	
	  const char cstr[] = "subject";
	  std::string s ("subject");
	  std::regex e ("(sub)(.*)");
	
	  if (std::regex_match (s,e))
		std::cout << "string object matched\n";
	
	  if ( std::regex_match ( s.begin(), s.end(), e ) )
		std::cout << "range matched\n";
	
	  std::cmatch cm;	 // same as std::match_results<const char*> cm;
	  std::regex_match (cstr,cm,e);
	  std::cout << "string literal with " << cm.size() << " matches\n";
	
	  std::smatch sm;	 // same as std::match_results<string::const_iterator> sm;
	  std::regex_match (s,sm,e);
	  std::cout << "string object with " << sm.size() << " matches\n";
	
	  std::regex_match ( s.cbegin(), s.cend(), sm, e);
	  std::cout << "range with " << sm.size() << " matches\n";
	
	  // using explicit flags:
	  std::regex_match ( cstr, cm, e, std::regex_constants::match_default );
	
	  std::cout << "the matches were: ";
	  for (unsigned i=0; i<cm.size(); ++i) {
		std::cout << "[" << cm[i] << "] ";
	  }
	
	  std::cout << std::endl;
	
	  return 0;
	}

	
	**/	

}

#define tag_std_container
/**
 * https://zh.cppreference.com/w/cpp/container
 * 头文件
	<array>				std::array 是固定大小数组的容器
	<vector>			std::vector 是封装动态数组的顺序容器
	<deque>				std::deque 是双向队列
	<forward_list>		std::forward_list 单向链表，固定的插入/删除时间
	<list> 				std::list 双向链表，固定的插入/删除时间
	<stack>				std::stack 栈容器，先进后出
	<map>				std::map 键值对 关系容器(不允许重复)
	<map>				std::multimap 一对多键值对 关系容器(允许重复)
	<set>				std::set 元素唯一的集合容器
	<set>				std::multiset 元素唯一的集合容器
	<unordered_map>		std::unordered_map 无序键值对，同map
	<unordered_map>		std::unordered_multimap 不排序，所以随机访问快，同multimap
	<unordered_set>		std::unordered_set 不排序，所以随机访问快
	<unordered_set>		std::unordered_multiset 不排序，所以随机访问快，同set

 */
namespace std
{

/**
 * refer https://zh.cppreference.com/w/cpp/container/array
 * @help_guide
 * Array header (since C++11) 
 * Header that defines the fixed-size array container class:
 * 泛型数组,可按下标访问
 */

/**
 * #include<array>
 * 
 * Example:
#include <string>
#include <iterator>
#include <iostream>
#include <algorithm>
#include <array>

int main()
{
    // 用聚合初始化构造
    std::array<int, 3> a1{ {1, 2, 3} }; // CWG 1270 重申前的 C++11 中要求双花括号
                                        // （ C++11 之后的版本和 C++14 起不要求）
    std::array<int, 3> a2 = {1, 2, 3};  // = 后决不要求
    std::array<std::string, 2> a3 = { std::string("a"), "b" };

    // 支持容器操作
    std::sort(a1.begin(), a1.end());
    std::reverse_copy(a2.begin(), a2.end(), 
                    std::ostream_iterator<int>(std::cout, " "));

    std::cout << '\n';

    // 支持带范围 for 循环
    for(const auto& s: a3)
        std::cout << s << ' ';
}
Output resutl:
 3 2 1 
 a b
 */
/*
// std::begin / std::end example
	#include <iostream>     // std::cout
	#include <vector>       // std::vector, std::begin, std::end

	int main () {
	  int foo[] = {10,20,30,40,50};
	  std::vector<int> bar;

	  // iterate foo: inserting into bar
	  for (auto it = std::begin(foo); it!=std::end(foo); ++it)
	    bar.push_back(*it);

	  // iterate bar: print contents:
	  std::cout << "bar contains:";
	  for (auto it = std::begin(bar); it!=std::end(bar); ++it)
	    std::cout << ' ' << *it;
	  std::cout << '\n';

	  return 0;
	}
*/

template< class T, std::size_t N > 
struct array
{
public:
    typedef T                                value_type;
    typedef T*                               pointer;
    typedef T&                               reference;
    typedef const T&                         const_reference;
    typedef value_type*                      iterator;
    typedef const value_type*	             const_iterator;
    typedef size_t                           size_type;
    typedef ptrdiff_t                        difference_type;
    typedef const T*                         const_pointer;
    typedef std::reverse_iterator<iterator>  reverse_iterator;
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

    T elems[N]; // exposition only
    
	// no explicit construct/copy/destroy for aggregate type

    ///< :::::::::element access:::::::::::
    constexpr reference       	operator[](size_type n);	///< access specified element
    constexpr reference       	at(size_type n);	///< access specified element with bounds checking
    constexpr reference       	front();	///<access the first element
    constexpr reference       	back();		///< access the last element
    constexpr T*				data() noexcept;	///< direct access to the underlying array

	/// const element access
	constexpr const_reference 	operator[](size_type n) const;
	constexpr const_reference 	at(size_type n) const;
	constexpr const_reference 	front() const;
	constexpr const_reference	back() const;
    constexpr const T*			data() const noexcept;

    ///< :::::::::iterators:::::::::::
	///< Return iterator to beginning
	///< Returns an iterator pointing to the first element in the array container.
	///< Notice that, unlike member array::front, which returns a reference to the first element, 
	///< this function returns a random access iterator pointing to it.
    constexpr iterator                begin() noexcept;
	constexpr iterator				  end() noexcept;
	
	constexpr reverse_iterator		  rbegin() noexcept;
	constexpr reverse_iterator		  rend() noexcept;

    constexpr const_iterator          cbegin() const noexcept;
	constexpr const_iterator          cend() const noexcept;
	
    constexpr const_reverse_iterator  crbegin() const noexcept;
	constexpr const_reverse_iterator  crend() const noexcept;


    /// :::::::::access:::::::::::
    constexpr size_type size() const noexcept;		///< returns the number of elements
    constexpr size_type max_size() const noexcept;	///< returns the maximum possible number of elements
    constexpr bool      empty() const noexcept; 	///< checks whether the container is empty
	
	 /// :::::::::modify:::::::::::
    constexpr void fill(const T& u);	///< fill the container with specified value
    constexpr void swap(array<T, N>&) noexcept(is_nothrow_swappable_v<T>);	///< swaps the contents TODO:

};


/**
 * @header  <vector>
 * @refer https://zh.cppreference.com/w/cpp/container/vector
 * @desc 泛型动态数组，相比array size 可变
 * @history (since C++11) 
 * @sample
 
#include <iostream>
#include <vector>
  
 int main()
 {
	// 创建含有整数的 vector
	std::vector<int> v = {7, 5, 16, 8};

	// 添加二个整数到 vector
	v.push_back(25);
	v.push_back(13);

	// 迭代并打印 vector 的值
	for(int n : v) {
	 std::cout << n << '\n';
	}
 }
 
 Output:
 
 7
 5
 16
 8
 25
 13
 */

template <class T, class Allocator = allocator<T> >
class vector 
{
public:
    // types:
    typedef T                                                   value_type;
    typedef value_type&                                         reference;
    typedef const value_type&                                   const_reference;
    typedef value_type*                                         iterator;
    typedef const value_type*                                   const_iterator; 
    typedef size_t                                              size_type;
    typedef ptrdiff_t                                           difference_type;
    typedef Allocator                                           allocator_type;
    typedef typename allocator_traits<Allocator>::pointer       pointer;
    typedef typename allocator_traits<Allocator>::const_pointer const_pointer;
    typedef std::reverse_iterator<iterator>                     reverse_iterator;
    typedef std::reverse_iterator<const_iterator>               const_reverse_iterator;

    // construct/copy/destroy:
    explicit vector(const Allocator& = Allocator());
    explicit vector(size_type n);
    vector(size_type n, const T& value,const Allocator& = Allocator());
    template <class InputIt> vector(InputIt first, InputIt last,const Allocator& = Allocator());
    vector(const vector<T,Allocator>& x);
    vector(vector&&);
    vector(const vector&, const Allocator&);
    vector(vector&&, const Allocator&);
    vector(initializer_list<T>, const Allocator& = Allocator());

    ~vector();
    vector<T,Allocator>& operator=(const vector<T,Allocator>& x);
    vector<T,Allocator>& operator=(vector<T,Allocator>&& x);
    vector& operator=(initializer_list<T>);
    template <class InputIt>
        void assign(InputIt first, InputIt last);
    void assign(size_type n, const T& t);
    void assign(initializer_list<T>);
    allocator_type get_allocator() const noexcept;

    // element access:
    reference       operator[](size_type n);
    const_reference operator[](size_type n) const;
    reference       at(size_type n);
    const_reference at(size_type n) const;
    reference       front();
    const_reference front() const;
    reference       back();
    const_reference back() const;

    // data access
    T*       data() noexcept;
    const T* data() const noexcept;


    // capacity:
    size_type size() const noexcept;
    size_type max_size() const noexcept;
    void      resize(size_type sz);
    void      resize(size_type sz, const T& c);
    size_type capacity() const noexcept;
	///< Test whether vector is empty 
    bool empty() const noexcept;
    void      reserve(size_type n);
    void      shrink_to_fit();

    // iterators:
    iterator                begin() noexcept;
    const_iterator          begin() const noexcept;
    reverse_iterator        rbegin() noexcept;
    const_reverse_iterator  rbegin() const noexcept;
    const_iterator          cbegin() const noexcept;
    const_reverse_iterator  crbegin() const noexcept;
	
    iterator                end() noexcept;
    const_iterator          end() const noexcept;
    reverse_iterator        rend() noexcept;
    const_reverse_iterator  rend() const noexcept;
    const_iterator          cend() const noexcept;
    const_reverse_iterator  crend() const noexcept;


    // modifiers:
    template <class... Args> void emplace_back(Args&&... args);
    void push_back(const T& x);
    void push_back(T&& x);
	void push_back (const value_type& val);
	void push_back (value_type&& val);

    void pop_back();

    template <class... Args> iterator emplace(const_iterator position, Args&&... args);
    iterator insert(const_iterator position, const T& x);
    iterator insert(const_iterator position, T&& x);
    iterator insert(const_iterator position, size_type n, const T& x);
    template <class InputIt>
        iterator insert (const_iterator position, InputIt first, 
                        InputIt last);
    iterator insert(const_iterator position, initializer_list<T>);

    iterator erase(const_iterator position);
    iterator erase(const_iterator first, const_iterator last);
    void     swap(vector<T,Allocator>&);
    void     clear() noexcept;
};



    /**
     * #include <deque>
     */
    template <class T, class Allocator = allocator<T> >
    class deque {
    public:
        // types:
        typedef value_type&                                         reference;
        typedef const value_type&                                   const_reference;
        typedef value_type*                                         iterator;
        typedef /*implementation-defined*/                          const_iterator; 
        typedef /*implementation-defined*/                          size_type;
        typedef /*implementation-defined*/                          difference_type;
        typedef T                                                   value_type;
        typedef Allocator                                           allocator_type;
        typedef typename allocator_traits<Allocator>::pointer       pointer;
        typedef typename allocator_traits<Allocator>::const_pointer const_pointer;
        typedef std::reverse_iterator<iterator>                     reverse_iterator;
        typedef std::reverse_iterator<const_iterator>               const_reverse_iterator;
    
        // construct/copy/destroy:
        explicit deque(const Allocator& = Allocator());
        explicit deque(size_type n);
        deque(size_type n, const T& value,const Allocator& = Allocator());
        template <class InputIterator>
            deque(InputIterator first, InputIterator last,const Allocator& = Allocator());
        deque(const deque<T,Allocator>& x);
        deque(deque&&);
        deque(const deque&, const Allocator&);
        deque(deque&&, const Allocator&);
        deque(initializer_list<T>, const Allocator& = Allocator());
    
        ~deque();
        deque<T,Allocator>& operator=(const deque<T,Allocator>& x);
        deque<T,Allocator>& operator=(deque<T,Allocator>&& x);
        deque& operator=(initializer_list<T>);
        template <class InputIterator>
        void assign(InputIterator first, InputIterator last);
        void assign(size_type n, const T& t);
        void assign(initializer_list<T>);
        allocator_type get_allocator() const noexcept;
    
        // iterators:
        iterator                begin() noexcept;
        const_iterator          begin() const noexcept;
        iterator                end() noexcept;
        const_iterator          end() const noexcept;
    
        reverse_iterator        rbegin() noexcept;
        const_reverse_iterator  rbegin() const noexcept;
        reverse_iterator        rend() noexcept;
        const_reverse_iterator  rend() const noexcept;
    
        const_iterator          cbegin() noexcept;
        const_iterator          cend() noexcept;
        const_reverse_iterator  crbegin() const noexcept;
        const_reverse_iterator  crend() const noexcept;
    
        // capacity:
        size_type size() const noexcept;
        size_type max_size() const noexcept;
        void      resize(size_type sz);
        void      resize(size_type sz, const T& c);
        void      shrink_to_fit();
        bool      empty() const noexcept;
    
        // element access:
        reference       operator[](size_type n);
        const_reference operator[](size_type n) const;
        reference       at(size_type n);
        const_reference at(size_type n) const;
        reference       front();
        const_reference front() const;
        reference       back();
        const_reference back() const;
    
        // modifiers:
        template <class... Args> void emplace_front(Args&&... args);
        template <class... Args> void emplace_back(Args&&... args);
        template <class... Args> iterator emplace(const_iterator position, Args&&... args);
    
        void push_front(const T& x);
        void push_front(T&& x);
        void push_back(const T& x);
        void push_back(T&& x);
    
        iterator insert(const_iterator position, const T& x);
        iterator insert(const_iterator position, T&& x);
        iterator insert(const_iterator position, size_type n, const T& x);
        template <class InputIterator>
            iterator insert (const_iterator position, InputIterator first, 
                            InputIterator last);
        iterator insert(const_iterator position, initializer_list<T>);
    
        void pop_front();
        void pop_back();
    
        iterator erase(const_iterator position);
        iterator erase(const_iterator first, const_iterator last);
        void     swap(deque<T,Allocator>&);
        void     clear() noexcept;
    };

    /**
     * #include <forward_list>
     */
    template <class T, class Allocator = allocator<T> >
    class forward_list {
    public:
        // types:
        typedef value_type&                                         reference;
        typedef const value_type&                                   const_reference;
        typedef value_type*                                         iterator;
        typedef /*implementation-defined*/                          const_iterator; 
        typedef /*implementation-defined*/                          size_type;
        typedef /*implementation-defined*/                          difference_type;
        typedef T                                                   value_type;
        typedef Allocator                                           allocator_type;
        typedef typename allocator_traits<Allocator>::pointer       pointer;
        typedef typename allocator_traits<Allocator>::const_pointer const_pointer;
    
        // construct/copy/destroy:
        explicit forward_list(const Allocator& = Allocator());
        explicit forward_list(size_type n);
        forward_list(size_type n, const T& value,const Allocator& = Allocator());
        template <class InputIterator>
            forward_list(InputIterator first, InputIterator last,
                        const Allocator& = Allocator());
        forward_list(const forward_list<T,Allocator>& x);
        forward_list(forward_list&&);
        forward_list(const forward_list&, const Allocator&);
        forward_list(forward_list&&, const Allocator&);
        forward_list(initializer_list<T>, const Allocator& = Allocator());
    
        ~forward_list();
        forward_list<T,Allocator>& operator=(const forward_list<T,Allocator>& x);
        forward_list<T,Allocator>& operator=(forward_list<T,Allocator>&& x);
        forward_list& operator=(initializer_list<T>);
        template <class InputIterator>
            void assign(InputIterator first, InputIterator last);
        void assign(size_type n, const T& t);
        void assign(initializer_list<T>);
        allocator_type get_allocator() const noexcept;
    
        // iterators:
        iterator                before_begin() noexcept;
        const_iterator          before_begin() const noexcept;
        iterator                begin() noexcept;
        const_iterator          begin() const noexcept;
        iterator                end() noexcept;
        const_iterator          end() const noexcept;
    
        const_iterator          cbegin() noexcept;
        const_iterator          cbefore_begin() const noexcept;
        const_iterator          cend() noexcept;
    
        // capacity:
        size_type max_size() const noexcept;
        bool      empty() const noexcept;
    
        // element access:
        reference       front();
        const_reference front() const;
    
        // modifiers:
        template <class... Args> void emplace_front(Args&&... args);
    
        void push_front(const T& x);
        void push_front(T&& x);
        void pop_front();
    
        template <class... Args> 
            iterator emplace_after(const_iterator position, Args&&... args);
        iterator insert_after(const_iterator position, const T& x);
        iterator insert_after(const_iterator position, T&& x);
    
        iterator insert_after(const_iterator position, size_type n, const T& x);
        template <class InputIterator>
            iterator insert_after(const_iterator position, InputIterator first, 
                                InputIterator last);
        iterator insert_after(const_iterator position, initializer_list<T> il);
    
        iterator erase_after(const_iterator position);
        iterator erase_after(const_iterator position, iterator last);
        void swap(forward_list<T,Allocator>&);
    
        void resize(size_type sz);
        void resize(size_type sz, const value_type& c);
        void clear() noexcept;
    
        // forward_list operations:
        void splice_after(const_iterator position, forward_list<T,Allocator>& x);
        void splice_after(const_iterator position, forward_list<T,Allocator>&& x);
        void splice_after(const_iterator position, forward_list<T,Allocator>& x,
                        const_iterator i);
        void splice_after(const_iterator position, forward_list<T,Allocator>&& x,
                        const_iterator i);
        void splice_after(const_iterator position, forward_list<T,Allocator>& x,
                        const_iterator first, const_iterator last);
        void splice_after(const_iterator position, forward_list<T,Allocator>&& x,
                        const_iterator first, const_iterator last);
    
        void remove(const T& value);
        template <class Predicate> void remove_if(Predicate pred);
    
        void unique();
        template <class BinaryPredicate> void unique(BinaryPredicate binary_pred);
    
        void merge(forward_list<T,Allocator>& x);
        void merge(forward_list<T,Allocator>&& x);
        template <class Compare> void merge(forward_list<T,Allocator>& x, Compare comp);
        template <class Compare> void merge(forward_list<T,Allocator>&& x, Compare comp);
    
        void sort();
        template <class Compare> void sort(Compare comp);
        void reverse() noexcept;
    };

/**
 * #include <list>
 */
template <class T, class Allocator = allocator<T> >
class list {
public:
    // types:
    typedef T                                                   value_type;        
    typedef value_type&                                         reference;
    typedef const value_type&                                   const_reference;
    typedef value_type*                                         iterator;
    typedef const value_type*                                   const_iterator; 
    typedef size_t                                              size_type;
    typedef ptrdiff_t                                           difference_type;

    typedef Allocator                                           allocator_type;
    typedef typename allocator_traits<Allocator>::pointer       pointer;
    typedef typename allocator_traits<Allocator>::const_pointer const_pointer;
    typedef std::reverse_iterator<iterator>                     reverse_iterator;
    typedef std::reverse_iterator<const_iterator>               const_reverse_iterator;

    // construct/copy/destroy:
    explicit list(const Allocator& = Allocator());
    explicit list(size_type n);
    list(size_type n, const T& value,const Allocator& = Allocator());
    template <class InputIterator> list(InputIterator first, InputIterator last,const Allocator& = Allocator());
    list(const list<T,Allocator>& x);
    list(list&&);
    list(const list&, const Allocator&);
    list(list&&, const Allocator&);
    list(initializer_list<T>, const Allocator& = Allocator());
    ~list();

	
    list<T,Allocator>& operator=(const list<T,Allocator>& x);
    list<T,Allocator>& operator=(list<T,Allocator>&& x);
    list& operator=(initializer_list<T>);

	
    template <class InputIterator> void assign(InputIterator first, InputIterator last);
    void assign(size_type n, const T& t);
    void assign(initializer_list<T>);

	
    allocator_type get_allocator() const noexcept;

    // iterators:
    iterator                begin() noexcept;
    const_iterator          begin() const noexcept;
    iterator                end() noexcept;
    const_iterator          end() const noexcept;

    reverse_iterator        rbegin() noexcept;
    const_reverse_iterator  rbegin() const noexcept;
    reverse_iterator        rend() noexcept;
    const_reverse_iterator  rend() const noexcept;

    const_iterator          cbegin() const noexcept;
    const_iterator          cend() const noexcept;
    const_reverse_iterator  crbegin() const noexcept;
    const_reverse_iterator  crend() const noexcept;

    // capacity:
    size_type size() const noexcept;
    size_type max_size() const noexcept;
    void      resize(size_type sz);
    void      resize(size_type sz, const T& c);
    bool      empty() const noexcept;

    // element access:
    reference       front();
    const_reference front() const;
    reference       back();
    const_reference back() const;

    // modifiers:
    template <class... Args> void emplace_front(Args&&... args);
    void push_front(const T& x);
    void push_front(T&& x);
	
    void pop_front();
    template <class... Args> void emplace_back(Args&&... args);
    void pop_back();

    template <class... Args> iterator emplace(const_iterator position, Args&&... args);
    iterator insert(const_iterator position, const T& x);
    iterator insert(const_iterator position, T&& x);
    iterator insert(const_iterator position, size_type n, const T& x);
    template <class InputIterator>
        iterator insert (const_iterator position, InputIterator first, 
                        InputIterator last);
    iterator insert(const_iterator position, initializer_list<T>);


    iterator erase(const_iterator position);
    iterator erase(const_iterator first, const_iterator last);
    void     swap(list<T,Allocator>&);
    void     clear() noexcept;

    // list operations:
    void splice(const_iterator position, list<T,Allocator>& x);
    void splice(const_iterator position, list<T,Allocator>&& x);
    void splice(const_iterator position, list<T,Allocator>& x,const_iterator i);
    void splice(const_iterator position, list<T,Allocator>&& x,const_iterator i);
    void splice(const_iterator position, list<T,Allocator>& x,const_iterator first, const_iterator last);
    void splice(const_iterator position, list<T,Allocator>&& x,const_iterator first, const_iterator last);

    void remove(const T& value);
    template <class Predicate> void remove_if(Predicate pred);

    void unique();
    template <class BinaryPredicate> void unique(BinaryPredicate binary_pred);

    void merge(list<T,Allocator>& x);
    void merge(list<T,Allocator>&& x);
    template <class Compare> void merge(list<T,Allocator>& x, Compare comp);
    template <class Compare> void merge(list<T,Allocator>&& x, Compare comp);


    void sort();
    template <class Compare> void sort(Compare comp);

    void reverse() noexcept;
};




template <class Key, class Compare = less<Key>,
class Allocator = allocator<Key> >
class set
{
public:
    // types:
    typedef Key key_type;
    typedef Key value_type;
    typedef Compare key_compare;
    typedef Compare value_compare;
    typedef Allocator allocator_type;
    typedef value_type& reference;
    typedef const value_type& const_reference;
    typedef value_type*                                         iterator;
    typedef /*implementation-defined*/ const_iterator;
    typedef /*implementation-defined*/ size_type;
    typedef /*implementation-defined*/ difference_type;
    typedef typename allocator_traits<Allocator>::pointer pointer;
    typedef typename allocator_traits<Allocator>::const_pointer const_pointer;
    typedef std::reverse_iterator<iterator> reverse_iterator;
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

    // construct/copy/destroy:
    explicit set(const Compare& comp = Compare(),
                const Allocator& = Allocator());
    template <class InputIterator>
    set(InputIterator first, InputIterator last,
        const Compare& comp = Compare(), const Allocator& = Allocator());
    set(const set<Key,Compare,Allocator>& x);
    set(set<Key,Compare,Allocator>&& x);
    explicit set(const Allocator&);
    set(const set&, const Allocator&);
    set(set&&, const Allocator&);
    set(initializer_list<value_type>,
        const Compare& = Compare(),
        const Allocator& = Allocator());
    ~set();

    set<Key,Compare,Allocator>& operator= (const set<Key,Compare,Allocator>& x);
    set<Key,Compare,Allocator>& operator= (set<Key,Compare,Allocator>&& x);
    set& operator=(initializer_list<value_type>);
    allocator_type get_allocator() const noexcept;

    // iterators:
    iterator        begin() noexcept;
    const_iterator  begin() const noexcept;
    iterator        end() noexcept;
    const_iterator  end() const noexcept;

    reverse_iterator        rbegin() noexcept;
    const_reverse_iterator  rbegin() const noexcept;
    reverse_iterator        rend() noexcept;
    const_reverse_iterator  rend() const noexcept;

    const_iterator          cbegin() const noexcept;
    const_iterator          cend() const noexcept;
    const_reverse_iterator  crbegin() const noexcept;
    const_reverse_iterator  crend() const noexcept;

    // capacity:
    bool        empty() const noexcept;
    size_type   size() const noexcept;
    size_type   max_size() const noexcept;

    // modifiers:
    template <class... Args> pair<iterator, bool> emplace(Args&&... args);
    template <class... Args> 
        iterator emplace_hint(const_iterator position, Args&&... args);

    pair<iterator,bool> insert(const value_type& x);
    pair<iterator,bool> insert(value_type&& x);
    iterator insert(const_iterator position, const value_type& x);
    iterator insert(const_iterator position, value_type&& x);
    template <class InputIterator>
    void insert(InputIterator first, InputIterator last);
    void insert(initializer_list<value_type>);

    iterator erase(const_iterator position);
    size_type erase(const key_type& x);
    iterator erase(const_iterator first, const_iterator last);

    void swap(set<Key,Compare,Allocator>&);
    void clear() noexcept;

    // observers:
    key_compare   key_comp() const;
    value_compare value_comp() const;

    // set operations:
    iterator       find(const key_type& x);
    const_iterator find(const key_type& x) const;
    size_type      count(const key_type& x) const;
    iterator       lower_bound(const key_type& x);
    const_iterator lower_bound(const key_type& x) const;
    iterator       upper_bound(const key_type& x);
    const_iterator upper_bound(const key_type& x) const;
    pair<iterator,iterator> equal_range(const key_type& x);
    pair<const_iterator,const_iterator> equal_range(const key_type& x) const;
};

template <class Key, class T, class Compare = less<Key>,
          class Allocator = allocator<pair<const Key, T> > >
class map 
{
public:
    // types:
    typedef Key                                                 key_type;
    typedef T                                                   mapped_type;
    typedef pair<const Key, T>                                  value_type;
    typedef Compare                                             key_compare;
    typedef Allocator                                           allocator_type;
    typedef value_type&                                         reference;
    typedef const value_type&                                   const_reference;
    typedef /*implementation-defined*/                          iterator;
    typedef /*implementation-defined*/                          const_iterator; 
    typedef /*implementation-defined*/                          size_type;
    typedef /*implementation-defined*/                          difference_type;
    typedef typename allocator_traits<Allocator>::pointer       pointer;
    typedef typename allocator_traits<Allocator>::const_pointer const_pointer;
    typedef std::reverse_iterator<iterator>                     reverse_iterator;
    typedef std::reverse_iterator<const_iterator>               const_reverse_iterator;
 
    class value_compare {
        friend class map;
    protected:
        Compare comp;
        value_compare(Compare c) : comp(c) {}
    public:
        typedef bool        result_type;
        typedef value_type  first_argument_type;
        typedef value_type  second_argument_type;
        bool operator()(const value_type& x, const value_type& y) const {
            return comp(x.first, y.first);
        }
    };
 
    explicit map(const Compare& comp = Compare(),
                 const Allocator& = Allocator());
    template <class InputIterator>
        map(InputIterator first, InputIterator last,
            const Compare& comp = Compare(), const Allocator& = Allocator());
    map(const map<Key,T,Compare,Allocator>& x);
    map(map<Key,T,Compare,Allocator>&& x);
    explicit map(const Allocator&);
    map(const map&, const Allocator&);
    map(map&&, const Allocator&);
    map(initializer_list<value_type>,
        const Compare& = Compare(),
        const Allocator& = Allocator());
 
    ~map();
 
    map<Key,T,Compare,Allocator>&
        operator=(const map<Key,T,Compare,Allocator>& x);
    map<Key,T,Compare,Allocator>&
        operator=(map<Key,T,Compare,Allocator>&& x);
    map& operator=(initializer_list<value_type>);
 
    allocator_type get_allocator() const noexcept;
 
 
    // iterators:
    iterator                begin() noexcept;
    const_iterator          begin() const noexcept;
    iterator                end() noexcept;
    const_iterator          end() const noexcept;
 
    reverse_iterator        rbegin() noexcept;
    const_reverse_iterator  rbegin() const noexcept;
    reverse_iterator        rend() noexcept;
    const_reverse_iterator  rend() const noexcept;
 
    const_iterator          cbegin() noexcept;
    const_iterator          cend() noexcept;
    const_reverse_iterator  crbegin() const noexcept;
    const_reverse_iterator  crend() const noexcept;
 
    // capacity:
    bool      empty() const noexcept;
    size_type size() const noexcept;
    size_type max_size() const noexcept;
 
    // element access:
    T& operator[](const key_type& x);
    T& operator[](key_type&& x);
    T&       at(const key_type& x);
    const T& at(const key_type& x) const;
 
    // modifiers:
    template <class... Args> pair<iterator, bool> emplace(Args&&... args);
    template <class... Args> 
        iterator emplace_hint(const_iterator position, Args&&... args);
    pair<iterator, bool> insert(const value_type& x);
    template <class P> pair<iterator, bool> insert(P&& x);
        iterator insert(const_iterator position, const value_type& x);
    template <class P>
        iterator insert(const_iterator position, P&&);
    template <class InputIterator>
        void insert(InputIterator first, InputIterator last);
    void insert(initializer_list<value_type>);
 
    iterator erase(const_iterator position);
    size_type erase(const key_type& x);
    iterator erase(const_iterator first, const_iterator last);
    void swap(map<Key,T,Compare,Allocator>&);
    void clear() noexcept;
 
    // observers:
    key_compare   key_comp() const;
    value_compare value_comp() const;
 
    //map operations:
    iterator        find(const key_type& x);
    const_iterator  find(const key_type& x) const;
    size_type       count(const key_type& x) const;
 
    iterator        lower_bound(const key_type& x);
    const_iterator  lower_bound(const key_type& x) const;
    iterator        upper_bound(const key_type& x);
    const_iterator  upper_bound(const key_type& x) const;
 
    pair<iterator,iterator> 
        equal_range(const key_type& x);
    pair<const_iterator,const_iterator> 
        equal_range(const key_type& x) const;
};


template <class Key, class Compare = less<Key>,
class Allocator = allocator<Key> >
class multiset
{
public:
    // types:
    typedef Key key_type;
    typedef Key value_type;
    typedef Compare key_compare;
    typedef Compare value_compare;
    typedef Allocator allocator_type;
    typedef value_type& reference;
    typedef const value_type& const_reference;
    typedef /*implementation-defined*/ iterator;
    typedef /*implementation-defined*/ const_iterator;
    typedef /*implementation-defined*/ size_type;
    typedef /*implementation-defined*/ difference_type;
    typedef typename allocator_traits<Allocator>::pointer pointer;
    typedef typename allocator_traits<Allocator>::const_pointer const_pointer;
    typedef std::reverse_iterator<iterator> reverse_iterator;
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
    // construct/copy/destroy:
    explicit multiset(const Compare& comp = Compare(),
                 const Allocator& = Allocator());
    template <class InputIterator>
    multiset(InputIterator first, InputIterator last,
        const Compare& comp = Compare(), const Allocator& = Allocator());
    multiset(const multiset<Key,Compare,Allocator>& x);
    multiset(multiset<Key,Compare,Allocator>&& x);
    explicit multiset(const Allocator&);
    multiset(const multiset&, const Allocator&);
    multiset(multiset&&, const Allocator&);
    multiset(initializer_list<value_type>,
        const Compare& = Compare(),
        const Allocator& = Allocator());
    ~multiset();
 
    multiset<Key,Compare,Allocator>& operator= (const multiset<Key,Compare,Allocator>& x);
    multiset<Key,Compare,Allocator>& operator= (multiset<Key,Compare,Allocator>&& x);
    multiset& operator=(initializer_list<value_type>);
    allocator_type get_allocator() const noexcept;
 
    // iterators:
    iterator        begin() noexcept;
    const_iterator  begin() const noexcept;
    iterator        end() noexcept;
    const_iterator  end() const noexcept;
 
    reverse_iterator        rbegin() noexcept;
    const_reverse_iterator  rbegin() const noexcept;
    reverse_iterator        rend() noexcept;
    const_reverse_iterator  rend() const noexcept;
 
    const_iterator          cbegin() const noexcept;
    const_iterator          cend() const noexcept;
    const_reverse_iterator  crbegin() const noexcept;
    const_reverse_iterator  crend() const noexcept;
 
    // capacity:
    bool        empty() const noexcept;
    size_type   size() const noexcept;
    size_type   max_size() const noexcept;
 
    // modifiers:
    template <class... Args> pair<iterator, bool> emplace(Args&&... args);
    template <class... Args> 
        iterator emplace_hint(const_iterator position, Args&&... args);
 
    pair<iterator,bool> insert(const value_type& x);
    pair<iterator,bool> insert(value_type&& x);
    iterator insert(const_iterator position, const value_type& x);
    iterator insert(const_iterator position, value_type&& x);
    template <class InputIterator>
    void insert(InputIterator first, InputIterator last);
    void insert(initializer_list<value_type>);
 
    iterator erase(const_iterator position);
    size_type erase(const key_type& x);
    iterator erase(const_iterator first, const_iterator last);
 
    void swap(multiset<Key,Compare,Allocator>&);
    void clear() noexcept;
 
    // observers:
    key_compare   key_comp() const;
    value_compare value_comp() const;
 
    // multiset operations:
    iterator       find(const key_type& x);
    const_iterator find(const key_type& x) const;
    size_type      count(const key_type& x) const;
    iterator       lower_bound(const key_type& x);
    const_iterator lower_bound(const key_type& x) const;
    iterator       upper_bound(const key_type& x);
    const_iterator upper_bound(const key_type& x) const;
    pair<iterator,iterator> equal_range(const key_type& x);
    pair<const_iterator,const_iterator> equal_range(const key_type& x) const;
};

template <class Key, class T, class Compare = less<Key>,
          class Allocator = allocator<pair<const Key, T> > >
class multimap {
public:
    // types:
    typedef Key                                                 key_type;
    typedef T                                                   mapped_type;
    typedef pair<const Key, T>                                  value_type;
    typedef Compare                                             key_compare;
    typedef Allocator                                           allocator_type;
    typedef value_type&                                         reference;
    typedef const value_type&                                   const_reference;
    typedef /*implementation-defined*/                          iterator;
    typedef /*implementation-defined*/                          const_iterator; 
    typedef /*implementation-defined*/                          size_type;
    typedef /*implementation-defined*/                          difference_type;
    typedef typename allocator_traits<Allocator>::pointer       pointer;
    typedef typename allocator_traits<Allocator>::const_pointer const_pointer;
    typedef std::reverse_iterator<iterator>                     reverse_iterator;
    typedef std::reverse_iterator<const_iterator>               const_reverse_iterator;
 
    class value_compare {
        friend class multimap;
    protected:
        Compare comp;
        value_compare(Compare c) : comp(c) {}
    public:
        typedef bool        result_type;
        typedef value_type  first_argument_type;
        typedef value_type  second_argument_type;
        bool operator()(const value_type& x, const value_type& y) const {
            return comp(x.first, y.first);
        }
    };
 
    explicit multimap(const Compare& comp = Compare(),
                 const Allocator& = Allocator());
    template <class InputIterator>
        multimap(InputIterator first, InputIterator last,
            const Compare& comp = Compare(), const Allocator& = Allocator());
    multimap(const multimap<Key,T,Compare,Allocator>& x);
    multimap(multimap<Key,T,Compare,Allocator>&& x);
    explicit multimap(const Allocator&);
    multimap(const multimap&, const Allocator&);
    multimap(multimap&&, const Allocator&);
    multimap(initializer_list<value_type>,
        const Compare& = Compare(),
        const Allocator& = Allocator());
 
    ~multimap();
 
    multimap<Key,T,Compare,Allocator>&
        operator=(const multimap<Key,T,Compare,Allocator>& x);
    multimap<Key,T,Compare,Allocator>&
        operator=(multimap<Key,T,Compare,Allocator>&& x);
    multimap& operator=(initializer_list<value_type>);
 
    allocator_type get_allocator() const noexcept;
 
 
    // iterators:
    iterator                begin() noexcept;
    const_iterator          begin() const noexcept;
    iterator                end() noexcept;
    const_iterator          end() const noexcept;
 
    reverse_iterator        rbegin() noexcept;
    const_reverse_iterator  rbegin() const noexcept;
    reverse_iterator        rend() noexcept;
    const_reverse_iterator  rend() const noexcept;
 
    const_iterator          cbegin() noexcept;
    const_iterator          cend() noexcept;
    const_reverse_iterator  crbegin() const noexcept;
    const_reverse_iterator  crend() const noexcept;
 
    // capacity:
    bool      empty() const noexcept;
    size_type size() const noexcept;
    size_type max_size() const noexcept;
 
    // modifiers:
    template <class... Args> pair<iterator, bool> emplace(Args&&... args);
    template <class... Args> iterator emplace_hint(const_iterator position, Args&&... args);
    pair<iterator, bool> insert(const value_type& x);
    template <class P> pair<iterator, bool> insert(P&& x);
        iterator insert(const_iterator position, const value_type& x);
    template <class P>
        iterator insert(const_iterator position, P&&);
    template <class InputIterator>
        void insert(InputIterator first, InputIterator last);
    void insert(initializer_list<value_type>);
 
    iterator erase(const_iterator position);
    size_type erase(const key_type& x);
    iterator erase(const_iterator first, const_iterator last);
    void swap(multimap<Key,T,Compare,Allocator>&);
    void clear() noexcept;
 
    // observers:
    key_compare   key_comp() const;
    value_compare value_comp() const;
 
    //multimap operations:
    iterator        find(const key_type& x);
    const_iterator  find(const key_type& x) const;
    size_type       count(const key_type& x) const;
 
    iterator        lower_bound(const key_type& x);
    const_iterator  lower_bound(const key_type& x) const;
    iterator        upper_bound(const key_type& x);
    const_iterator  upper_bound(const key_type& x) const;
 
    pair<iterator,iterator> 
        equal_range(const key_type& x);
    pair<const_iterator,const_iterator> 
        equal_range(const key_type& x) const;
};

/**
 * #include <stack>
 */ 
template <class T, class Container = std::deque<T> >
class stack {
 public:
    typedef typename Container::value_type value_type;
    typedef typename Container::reference reference;
    typedef typename Container::const_reference const_reference;
    typedef typename Container::size_type size_type;
    typedef Container container_type;
 
 protected:
    Container c;
 
 public:
    explicit stack(const Container&);
    explicit stack(Container&& = Container());
    template <class Alloc> explicit stack(const Alloc&);
    template <class Alloc> stack(const Container&, const Alloc&);
    template <class Alloc> stack(Container&&, const Alloc&);
    template <class Alloc> stack(const stack&, const Alloc&);
    template <class Alloc> stack(stack&&, const Alloc&);
 
    bool empty() const {
        return c.empty();
    }
    size_type size() const {
        return c.size();
    }
    reference top() {
        return c.back();
    }
    const_reference top() const {
        return c.back();
    }
    void push(const value_type& x) {
        c.push_back(x);
    }
    void push(value_type&& x) {
        c.push_back(std::move(x));
    }
    template <class... Args> void emplace(Args&&... args) {
        c.emplace_back(std::forward<Args>(args)...);
    }
    void pop() {
        c.pop_back();
    }
    void swap(stack& s) noexcept(noexcept(swap(c, s.c))) {
        using std::swap;
        swap(c, s.c);
    }
};

/**
 * #include <queue>
 */
template <class T, class Container = deque<T> >
class queue {
 public:
    typedef typename Container::value_type value_type;
    typedef typename Container::reference reference;
    typedef typename Container::const_reference const_reference;
    typedef typename Container::size_type size_type;
    typedef Container container_type;
 protected:
    Container c;
 public:
    explicit queue(const Container&);
    explicit queue(Container&& = Container());
    template <class Alloc> explicit queue(const Alloc&);
    template <class Alloc> queue(const Container&, const Alloc&);
    template <class Alloc> queue(Container&&, const Alloc&);
    template <class Alloc> queue(const queue&, const Alloc&);
    template <class Alloc> queue(queue&&, const Alloc&);
 
    bool empty() const {
        return c.empty();
    }
    size_type size() const {
        return c.size();
    }
    reference front() {
        return c.front();
    }
    const_reference front() const {
        return c.front();
    }
    reference back() {
        return c.back();
    }
    const_reference back() const {
        return c.back();
    }
    void push(const value_type& x) {
        c.push_back(x);
    }
    void push(value_type&& x) {
        c.push_back(std::move(x));
    }
    template <class... Args> void emplace(Args&&... args) {
        c.emplace_back(std::forward<Args>(args)...);
    }
    void pop() {
        c.pop_front();
    }
    void swap(queue& q) noexcept(noexcept(swap(c, q.c))) {
        using std::swap;
        swap(c, q.c);
    }
};

/**
 * #include <queue>
 */

template <class T,
          class Container = vector<T>,
          class Compare = less<typename Container::value_type> >
class priority_queue {
 public:
    typedef typename Container::value_type value_type;
    typedef typename Container::reference reference;
    typedef typename Container::const_reference const_reference;
    typedef typename Container::size_type size_type;
    typedef Container container_type;
 protected:
    Container c;
    Compare comp;
 public:
    priority_queue(const Compare& x, const Container&);
    explicit priority_queue(const Compare& x = Compare(), Container&& = Container());
    template <class InputIterator>
    priority_queue(InputIterator first, InputIterator last,
                       const Compare& x, const Container&);
    template <class InputIterator>
    priority_queue(InputIterator first, InputIterator last,
                   const Compare& x = Compare(), Container&& = Container());
    template <class Alloc> explicit priority_queue(const Alloc&);
    template <class Alloc> priority_queue(const Compare&, const Alloc&);
    template <class Alloc> priority_queue(const Compare&,
                                          const Container&, const Alloc&);
    template <class Alloc> priority_queue(const Compare&,
                                          Container&&, const Alloc&);
    template <class Alloc> priority_queue(const priority_queue&, const Alloc&);
    template <class Alloc> priority_queue(priority_queue&&, const Alloc&);
 
    bool empty() const {
        return c.empty();
    }
    size_type size() const {
        return c.size();
    }
    const_reference top() const {
        return c.front();
    }
    void push(const value_type& x);
    void push(value_type&& x);
    template <class... Args> void emplace(Args&&... args);
    void pop();
    void swap(priority_queue& q) noexcept( noexcept(swap(c, q.c))
                                        && noexcept(swap(comp, q.comp))) {
        using std::swap;
        swap(c, q.c);
        swap(comp, q.comp);
    }
};

	
/**
* @header  <bitset>
* @refer http://www.cplusplus.com/reference/bitset/
* @desc bit数组
* @history 
* @sample
*
*/

template<size_t N>
class bitset
{
public:
    // bit reference:
    class reference
    {
        friend class bitset;
        reference() noexcept;
    public:
        ~reference() noexcept;
        reference& operator=(bool x) noexcept;          //  for b[i] = x;
        reference& operator=(const reference&) noexcept;//  for b[i] = b[j];
        bool operator~() const noexcept;                //  flips the bit
        operator bool() const noexcept;                 //  for x = b[i];
        reference& flip() noexcept;                     //  for b[i].flip();
 
    };
 
    //constructors:
    constexpr bitset() noexcept;
    constexpr bitset(unsigned long long val) noexcept;
	
    template<class charT, class traits, class Allocator>
        explicit bitset(
						const basic_string<charT,traits,Allocator>& str,
						typename basic_string<charT,traits,Allocator>::size_type pos = 0,
						typename basic_string<charT,traits,Allocator>::size_type n = basic_string<charT,traits,Allocator>::npos,
						charT zero = charT('0'), charT one = charT('1')
	        );
	
	template <class charT>
	explicit bitset(const charT* str,
					typename basic_string<charT>::size_type n = basic_string<charT>::npos,
					charT zero = charT('0'), charT one = charT('1')
					);
	// Sample
	// bitset operations:
	/**
	// bitset operators
	#include <iostream>       // std::cout
	#include <string>         // std::string
	#include <bitset>         // std::bitset
	
	int main ()
	{
	  std::bitset<4> foo (std::string("1001"));
	  std::bitset<4> bar (std::string("0011"));
	
	  std::cout << (foo^=bar) << '\n';		 // 1010 (XOR,assign)
	  std::cout << (foo&=bar) << '\n';		 // 0010 (AND,assign)
	  std::cout << (foo|=bar) << '\n';		 // 0011 (OR,assign)
	
	  std::cout << (foo<<=2) << '\n';		 // 1100 (SHL,assign)
	  std::cout << (foo>>=1) << '\n';		 // 0110 (SHR,assign)
	
	  std::cout << (~bar) << '\n';			 // 1100 (NOT)
	  std::cout << (bar<<1) << '\n';		 // 0110 (SHL)
	  std::cout << (bar>>1) << '\n';		 // 0001 (SHR)
	
	  std::cout << (foo==bar) << '\n';		 // false (0110==0011)
	  std::cout << (foo!=bar) << '\n';		 // true  (0110!=0011)
	
	  std::cout << (foo&bar) << '\n';		 // 0010
	  std::cout << (foo|bar) << '\n';		 // 0111
	  std::cout << (foo^bar) << '\n';		 // 0101
	
	  return 0;
	}
	*/
	bitset<N>& operator&=(const bitset<N>& rhs) noexcept;	///< bit and 
	bitset<N>& operator|=(const bitset<N>& rhs) noexcept;	///< bit or  
	bitset<N>  operator~() const noexcept;					///< bit not  
	bitset<N>& operator^=(const bitset<N>& rhs) noexcept;
	bitset<N>& operator<<=(size_t pos) noexcept;			///< bit left shift   
	bitset<N>& operator>>=(size_t pos) noexcept;			///< bit right shift  
	bool operator==(const bitset<N>& rhs) const noexcept;
	bool operator!=(const bitset<N>& rhs) const noexcept;

	/// bit operation
	bitset<N>& set() noexcept;
	bitset<N>& reset() noexcept;
	bitset<N>& flip() noexcept;
	
	bitset<N>& set(size_t pos, bool val = true);
	bitset<N>& reset(size_t pos);
	bitset<N>& flip(size_t pos);

	// element access:
	constexpr bool operator[](size_t pos) const; // for b[i];
	reference operator[](size_t pos); // for b[i];

		
	size_t count() const noexcept;		///< Returns the number of bits in the bitset that are set
	constexpr size_t size() noexcept;	///< Returns the number of bits in the bitset.
	
	bool test(size_t pos) const; 	///< Returns whether the bit at position pos is set (i.e., whether it is one).
	bool all() const noexcept;		///< Returns whether all of the bits in the bitset are set (to one).
	bool any() const noexcept;		///< Returns whether any of the bits is set
	bool none() const noexcept;		///< Returns whether none of the bits is set
	
	///< Convert to string
	template <class charT = char,class traits = char_traits<charT>,class Allocator = allocator<charT> >
	basic_string<charT, traits, Allocator> to_string(charT zero = charT('0'), charT one = charT('1')) const;

	unsigned long to_ulong() const;			///< Convert to unsigned long
	unsigned long long to_ullong() const;	///< Convert to unsigned long long


};	

}


typedef unsigned long language_long;

#define tag_std_thread
/**
* @header 
<atomic>
<condition_variable>
<future>
<mutext>
<thread>
*/

namespace std 
{

/**
* @header  <atomic>
* @refer http://www.cplusplus.com/reference/atomic/
* @desc 用于线程同步
* @history (since C++11) 
* @sample
*/


/**
* @header  <<mutex>>
* @refer http://www.cplusplus.com/reference/<mutex>/
* @desc 用于线程同步
* @history (since C++11) 
* @sample
*/
class mutex 
{
	public:
		constexpr mutex() noexcept;
		~mutex();
		mutex(const mutex&) = delete;
		mutex& operator=(const mutex&) = delete;

		void lock();
		bool try_lock();
		void unlock();
		typedef language_long native_handle_type;
		native_handle_type native_handle();
};

class condition_variable_any 
{
	public:
		condition_variable_any();
		~condition_variable_any();
		condition_variable_any(const condition_variable_any&) = delete;
		condition_variable_any& operator=(const condition_variable_any&) = delete;

		void notify_one() noexcept;
		void notify_all() noexcept;
		template <class Lock> void wait(Lock& lock);
		template <class Lock, class Predicate> void wait(Lock& lock, Predicate pred);
		template <class Lock, class Clock, class Duration> 
			cv_status wait_until(Lock& lock,const chrono::time_point<Clock, Duration>& abs_time);
		template <class Lock, class Clock, class Duration, class Predicate>
		bool wait_until(Lock& lock,
		                const chrono::time_point<Clock, Duration>& abs_time,
		                Predicate pred);
		template <class Lock, class Rep, class Period>
		cv_status wait_for(Lock& lock,
		                   const chrono::duration<Rep, Period>& rel_time);
		template <class Lock, class Rep, class Period, class Predicate>
		bool wait_for(Lock& lock,const chrono::duration<Rep, Period>& rel_time,Predicate pred);
};

class shared_mutex
{
public:
	typedef language_long native_handle_type;

	shared_mutex();
	~shared_mutex();
	shared_mutex(const shared_mutex&) = delete;
	shared_mutex& operator=(const shared_mutex&) = delete;

	// Exclusive ownership
	void lock(); // blocking
	bool try_lock();
	void unlock();

	// Shared ownership
	void lock_shared(); // blocking
	bool try_lock_shared();
	void unlock_shared();

	// Getters
	native_handle_type native_handle();
};


class shared_timed_mutex
{
	public:
		shared_timed_mutex();
		~shared_timed_mutex();
		shared_timed_mutex(const shared_timed_mutex&) = delete;
		shared_timed_mutex& operator=(const shared_timed_mutex&) = delete;

		// Exclusive ownership
		void lock(); // blocking
		bool try_lock();
		template <class Rep, class Period>
		bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
		template <class Clock, class Duration>
		bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
		void unlock();

		// Shared ownership
		void lock_shared(); // blocking
		bool try_lock_shared();
		template <class Rep, class Period>
		bool try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time);
		template <class Clock, class Duration>
		bool try_lock_shared_until(const chrono::time_point<Clock, Duration>& abs_time);
		void unlock_shared();
};

/**
* @header  <thread>
* @refer http://www.cplusplus.com/reference/thread/
* @desc 线程操作
* @history (since C++11) 
* @sample
	#include <iostream>       // std::cout
	#include <thread>         // std::thread
	void foo() 
	{
	  // do stuff...
	}
	void bar(int x)
	{
	  // do stuff...
	}

	int main() 
	{
	  std::thread first (foo);     // spawn new thread that calls foo()
	  std::thread second (bar,0);  // spawn new thread that calls bar(0)

	  std::cout << "main, foo and bar now execute concurrently...\n";

	  // synchronize threads:
	  first.join();                // pauses until first finishes
	  second.join();               // pauses until second finishes

	  std::cout << "foo and bar completed.\n";

	  return 0;
	}

*/

class thread
{
 public:
	// types:
	class id;	///< Thread Id,Similar thread::get_id()
	typedef std::native_handle native_handle_type; ///< similar to thread::native_handle()
 
	// construct/copy/destroy:
	thread() noexcept;
	template <class F, class ...Args> explicit thread(F&& f, Args&&... args);
	~thread();
	thread(const thread&) = delete;
	thread(thread&&) noexcept;
	thread& operator=(const thread&) = delete;
	thread& operator=(thread&&) noexcept;
 
	// members:
	void swap(thread&) noexcept;
	bool joinable() const noexcept;
	void join();
	void detach();
	id get_id() const noexcept;
	native_handle_type native_handle();
 
	// static members:
	static unsigned hardware_concurrency() noexcept;
};



}
#define tag_std_io
ios_base
Base class for streams (class )
ios
Base class for streams (type-dependent components) (class )
istream
Input stream (class )
ostream
Output Stream (class )
iostream
Input/output stream (class )
ifstream
Input file stream class (class )
ofstream
Output file stream (class )
fstream
Input/output file stream class (class )
istringstream
Input string stream (class )
ostringstream
Output string stream (class )
stringstream
Input/output string stream (class )
streambuf
Base buffer class for streams (class )
filebuf
File stream buffer (class )
stringbuf
String stream buffer (class )



namespace std
{

}
#define tag_std_algorithm


namespace std
{
	
	/**
	 * <algorithm>
	 * refer http://www.cplusplus.com/reference/algorithm/
	 * @help_guide
	 * Array header (since C++11) 
	 * Header that defines the fixed-size array container class:
	 * 泛型数组,可按下标访问
	 */

	///<::::::::::::Non-modifying sequence operations::::::::::::::
	
	///< Test condition on all elements in range
	template <class InputIterator, class UnaryPredicate> bool all_of (InputIterator first, InputIterator last, UnaryPredicate pred);

	///< Test if any element in range fulfills condition	
	template <class InputIterator, class UnaryPredicate> bool any_of (InputIterator first, InputIterator last, UnaryPredicate pred);
	
	///< Test if no elements fulfill condition (function template )
	template <class InputIterator, class UnaryPredicate> bool none_of (InputIterator first, InputIterator last, UnaryPredicate pred);
	
	///< Apply function to range (function template )
	template <class InputIterator, class Function> Function  for_each (InputIterator first, InputIterator last, Function fn);

	

	///<Find value in range (function template )
	template <class InputIterator, class T> InputIterator find (InputIterator first, InputIterator last, const T& val);

	///<Find element in range (function template )
	template <class InputIterator, class UnaryPredicate> InputIterator find_if (InputIterator first, InputIterator last, UnaryPredicate pred);
	
	///<Find element in range (negative condition) (function template )
	template <class InputIterator, class UnaryPredicate> InputIterator find_if_not (InputIterator first, InputIterator last, UnaryPredicate pred);

	///<Find last subsequence in range (function template )
	template <class ForwardIterator1, class ForwardIterator2> ForwardIterator1 find_end (ForwardIterator1 first1, ForwardIterator1 last1,ForwardIterator2 first2, ForwardIterator2 last2);
	template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> ForwardIterator1 find_end (ForwardIterator1 first1, ForwardIterator1 last1,ForwardIterator2 first2, ForwardIterator2 last2,BinaryPredicate pred);

	///<Find element from set in range (function template )
	template <class InputIterator, class ForwardIterator> InputIterator find_first_of (InputIterator first1, InputIterator last1,ForwardIterator first2, ForwardIterator last2);

	template <class InputIterator, class ForwardIterator, class BinaryPredicate> InputIterator find_first_of (InputIterator first1, InputIterator last1,ForwardIterator first2, ForwardIterator last2,BinaryPredicate pred);


	

	///<Find equal adjacent elements in range (function template )

	template <class ForwardIterator> ForwardIterator adjacent_find (ForwardIterator first, ForwardIterator last);

	template <class ForwardIterator, class BinaryPredicate> ForwardIterator adjacent_find (ForwardIterator first, ForwardIterator last,BinaryPredicate pred);

	
	count
	///<Count appearances of value in range (function template )
	count_if
	///<Return number of elements in range satisfying condition (function template )
	mismatch
	///<Return first position where two ranges differ (function template )
	equal
	///<Test whether the elements in two ranges are equal (function template )
	is_permutation 
	Test whether range is permutation of another (function template )
	search
	Search range for subsequence (function template )
	search_n
	Search range for elements (function template )
	
	///<:::::::::::Modifying sequence operations:
	copy
	Copy range of elements (function template )
	copy_n 
	Copy elements (function template )
	copy_if 
	Copy certain elements of range (function template )
	copy_backward
	Copy range of elements backward (function template )
	move 
	Move range of elements (function template )
	move_backward 
	Move range of elements backward (function template )
	swap
	Exchange values of two objects (function template )
	swap_ranges
	Exchange values of two ranges (function template )
	iter_swap
	Exchange values of objects pointed to by two iterators (function template )
	transform
	Transform range (function template )
	replace
	Replace value in range (function template )
	replace_if
	Replace values in range (function template )
	replace_copy
	Copy range replacing value (function template )
	replace_copy_if
	Copy range replacing value (function template )
	fill
	Fill range with value (function template )
	fill_n
	Fill sequence with value (function template )
	generate
	Generate values for range with function (function template )
	generate_n
	Generate values for sequence with function (function template )
	remove
	Remove value from range (function template )
	remove_if
	Remove elements from range (function template )
	remove_copy
	Copy range removing value (function template )
	remove_copy_if
	Copy range removing values (function template )
	unique
	Remove consecutive duplicates in range (function template )
	unique_copy
	Copy range removing duplicates (function template )
	reverse
	Reverse range (function template )
	reverse_copy
	Copy range reversed (function template )
	rotate
	Rotate left the elements in range (function template )
	rotate_copy
	Copy range rotated left (function template )
	random_shuffle
	Randomly rearrange elements in range (function template )
	shuffle 
	Randomly rearrange elements in range using generator (function template )
	
	Partitions:
	is_partitioned 
	Test whether range is partitioned (function template )
	partition
	Partition range in two (function template )
	stable_partition
	Partition range in two - stable ordering (function template )
	partition_copy 
	Partition range into two (function template )
	partition_point 
	Get partition point (function template )
	
	///<Sorting:
	sort
	Sort elements in range (function template )
	stable_sort
	Sort elements preserving order of equivalents (function template )
	partial_sort
	Partially sort elements in range (function template )
	partial_sort_copy
	Copy and partially sort range (function template )
	is_sorted 
	Check whether range is sorted (function template )
	is_sorted_until 
	Find first unsorted element in range (function template )
	nth_element
	Sort element in range (function template )
	
	Binary search (operating on partitioned/sorted ranges):
	lower_bound
	Return iterator to lower bound (function template )
	upper_bound
	Return iterator to upper bound (function template )
	equal_range
	Get subrange of equal elements (function template )
	binary_search
	Test if value exists in sorted sequence (function template )
	
	Merge (operating on sorted ranges):
	merge
	Merge sorted ranges (function template )
	inplace_merge
	Merge consecutive sorted ranges (function template )
	includes
	Test whether sorted range includes another sorted range (function template )
	set_union
	Union of two sorted ranges (function template )
	set_intersection
	Intersection of two sorted ranges (function template )
	set_difference
	Difference of two sorted ranges (function template )
	set_symmetric_difference
	Symmetric difference of two sorted ranges (function template )
	
	///< Heap:
	push_heap
	Push element into heap range (function template )
	pop_heap
	Pop element from heap range (function template )
	make_heap
	Make heap from range (function template )
	sort_heap
	Sort elements of heap (function template )
	is_heap 
	Test if range is heap (function template )
	is_heap_until 
	Find first element not in heap order (function template )
	
	///< Min/max:
	///< Return the smallest (function template )
	template <class T>                const T&  min (const T& a, const T& b); ///< default
	template <class T, class Compare> const T&  min (const T& a, const T& b, Compare comp); ///< custom
	template <class T>                      T   min (initializer_list<T> il); ///< initializer list
	template <class T, class Compare>       T   min (initializer_list<T> il, Compare comp); ///< initializer list



	///< Return the largest (function template )
	template <class T>                const T&  max (const T& a, const T& b); ///< default
	template <class T, class Compare> const T&  max (const T& a, const T& b, Compare comp); ///< custom
	template <class T>                      T   max (initializer_list<T> il); ///< initializer list
	template <class T, class Compare>       T   max (initializer_list<T> il, Compare comp); ///< initializer list

	///< Return smallest and largest elements (function template )
	template <class T>                pair<const T&,const T&> minmax (const T& a, const T& b);
	template <class T, class Compare> pair<const T&,const T&> minmax (const T& a, const T& b, Compare comp);
	template <class T>                pair<T,T>               minmax (initializer_list<T> il);
	template <class T, class Compare> pair<T,T>               minmax (initializer_list<T> il, Compare comp);

	///< Return smallest element in range (function template )
	template <class ForwardIterator>                ForwardIterator min_element (ForwardIterator first, ForwardIterator last);//default 
	template <class ForwardIterator, class Compare> ForwardIterator min_element (ForwardIterator first, ForwardIterator last,Compare comp); //custom


	///< Return largest element in range (function template )
	template <class ForwardIterator>                ForwardIterator max_element (ForwardIterator first, ForwardIterator last);//default 
	template <class ForwardIterator, class Compare> ForwardIterator max_element (ForwardIterator first, ForwardIterator last,Compare comp); //custom


	///< Return smallest and largest elements in range (function template )
	template <class ForwardIterator>                pair<ForwardIterator,ForwardIterator> minmax_element (ForwardIterator first, ForwardIterator last);//default 
	template <class ForwardIterator, class Compare> pair<ForwardIterator,ForwardIterator> minmax_element (ForwardIterator first, ForwardIterator last, Compare comp);//custom


	
	///< Other:
	lexicographical_compare
	Lexicographical less-than comparison (function template )
	next_permutation
	Transform range to next permutation (function template )
	prev_permutation
	Transform range to previous permutation (function template )

};

#define tag_std_cpp
/**
Headers:
*/

namespace std
{

	/// std::type_index
	class type_index;


}


#define tag_std_others
/**
Headers:


<exception>
<functional>
<initializer_list>
<iterator>
<memory>
<new>				Low-level memory management utilities
<typeindex>
<typeinfo>
<type_traits>

<chrono>
<codecvt>
<complex>


<limits>
<locale>

<numeric>
<random>
<ratio>

<stdexcept>
<system_error>
<tuple>

<utility>
<valarray>









*/
namespace std
{


}


#define tag_std_cpp20
/**
Headers:
<concepts> 		(since C++20)	Fundamental library concepts
<coroutine> 	(since C++20)	Coroutine support library
<compare> 		(since C++20)	Three-way comparison operator support
<version> 		(since C++20)	supplies implementation-dependent library information
<contract> 		(since C++20)	Contract violation information
<span> 			(since C++20)	std::span view
<ranges> 		(since C++20)	Range access, primitives, requirements, utilities and adaptors
<bit> 			(since C++20)	Bit manipulation functions
<syncstream> 	(since C++20)	std::basic_osyncstream, std::basic_syncbuf, and typedefs

*/
namespace std
{

}

#endif
//end of file
